Integrated circuits (ICs) can be implemented to perform a variety of functions. Some ICs can be programmed to perform specified functions. One example of an IC that can be programmed is a field programmable gate array (FPGA). An FPGA typically includes an array of programmable tiles. These programmable tiles may include, for example, input/output blocks (IOBs), configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM), multipliers, digital signal processing blocks (DSPs), processors, clock managers, delay lock loops (DLLs), and so forth.
Each programmable tile typically includes both programmable interconnect circuitry and programmable logic circuitry. The programmable interconnect circuitry typically includes a large number of interconnect lines of varying lengths interconnected or coupled by programmable interconnect points (PIPs). The programmable logic circuitry implements the logic of a user design using programmable elements that may include, for example, function generators, registers, arithmetic logic, and so forth.
The programmable interconnect and programmable logic circuitries are typically programmed by loading a stream of configuration data into internal configuration memory cells that define how the programmable elements are configured. The configuration data may be read from memory (e.g., from an external programmable read-only memory or PROM) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
Another type of programmable IC is the complex programmable logic device, or CPLD. A CPLD includes two or more “function blocks” connected together and to input/output (I/O) resources by an interconnect switch matrix. Each function block of the CPLD includes a two-level AND/OR structure similar to those used in programmable logic arrays (PLAs) and programmable array logic (PAL) devices. In CPLDs, configuration data is typically stored on-chip in non-volatile memory. In some CPLDs, configuration data is stored on-chip in non-volatile memory, then downloaded to volatile memory as part of an initial configuration (programming) sequence.
For all of these programmable ICs, the functionality of the device is controlled by data bits provided to the device for that purpose. The data bits may be stored in volatile memory (e.g., static memory cells, as in FPGAs and some CPLDs), in non-volatile memory (e.g., FLASH memory, as in some CPLDs), or in any other type of memory cell.
Other programmable ICs are programmed by applying a processing layer, such as a metal layer, that programmably interconnects the various elements on the device. These programmable ICs are known as mask programmable devices. Programmable ICs may also be implemented in other ways, e.g., using fuse or antifuse technology. The phrase “programmable IC” may include, but is not limited to these devices and further may encompass devices that are only partially programmable. For example, one type of programmable IC includes a combination of hard-coded transistor logic and a programmable switch fabric that programmably interconnects the hard-coded transistor logic.
In order to implement a circuit design within an IC such as a programmable IC, the circuit design undergoes a process referred to as a design flow. The design flow generally includes synthesis, placement, and routing. Synthesis includes the conversion of an abstract, programmatic description of a circuit into a low-level design implementation. Synthesis also includes mapping the low-level circuit implementation to circuit elements available on the IC in which the circuit design will be implemented referred to as the “target IC.”
The abstract, programmatic description of the circuit design may be specified in a hardware description language (HDL). The abstract, programmatic description of the circuit describes behavior of the circuit and is also referred to as a “behavioral description” or a “register transfer level (RTL) description” of the circuit. The low level design implementation generated through synthesis typically is specified as inter-connected logic gates.
As part of synthesis, mapping correlates, or matches, the logic gates of the low-level circuit design to the various types of circuit blocks or resources that are actually available in the target IC. For example, since a lookup table (LUT) may implement a complex function, one or more logic gates of the low level design implementation may be mapped to a single LUT, or other programmable tile of the target IC. The mapped circuit design specifies the same functionality as the low level design implementation, albeit in terms of the particular circuit blocks available on the target IC as opposed to low-level logic gates.
Placement is the process of assigning elements of the mapped circuit design to particular instances of circuit blocks and/or resources having specific locations on the target IC. Once placed, a circuit element of the circuit design has a specific location on the target IC as opposed to only being assigned to a particular type of circuit block and/or resource as is the case after mapping and prior to placement. The location of the instance of the circuit block and/or resource on the target IC assigned to a circuit element of the circuit design is the location of that circuit element when placed. Routing is the process of selecting particular routing resources such as wires, PIPs, PIP settings, and/or other interconnect circuitry to electrically couple the various circuit blocks of the target IC.
Circuit designs may be evaluated against requirements set forth in a design specification after various stages of the design flow described above. Estimates of circuit design performance relating to timing, power consumption, or the like, may be compared with the requirements of the design specification to determine whether the requirements are met.